home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / valprint.c < prev    next >
C/C++ Source or Header  |  1992-03-25  |  18KB  |  679 lines
  1. /* Print values for GNU debugger gdb.
  2.    Copyright (C) 1986, 1988 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include <stdio.h>
  22. #include "defs.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25.  
  26. /* Maximum number of chars to print for a string pointer value
  27.    or vector contents.  */
  28.  
  29. static int print_max;
  30.  
  31. static void type_print_varspec_suffix ();
  32. static void type_print_varspec_prefix ();
  33. static void type_print_base ();
  34.  
  35. char **unsigned_type_table;
  36. char **signed_type_table;
  37. char **float_type_table;
  38.  
  39. /* Print the value VAL in C-ish syntax on stream STREAM.
  40.    FORMAT is a format-letter, or 0 for print in natural format of data type.
  41.    If the object printed is a string pointer, returns
  42.    the number of string bytes printed.  */
  43.  
  44. value_print (val, stream, format)
  45.      value val;
  46.      FILE *stream;
  47.      char format;
  48. {
  49.   register int i, n, typelen;
  50.  
  51.   if (val == 0)
  52.   {
  53.      printf_filtered ("<address of value unknown>");
  54.       return 0;
  55.   }
  56.  
  57.   /* A "repeated" value really contains several values in a row.
  58.      They are made by the @ operator.
  59.      Print such values as if they were arrays.  */
  60.  
  61.   if (VALUE_REPEATED (val))
  62.     {
  63.       n = VALUE_REPETITIONS (val);
  64.       typelen = TYPE_LENGTH (VALUE_TYPE (val));
  65.       fputc_filtered ('{', stream);
  66.       /* Print arrays of characters using string syntax.  */
  67.       if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
  68.       && format == 0)
  69.     {
  70.       fputc_filtered ('"', stream);
  71.       for (i = 0; i < n && i < print_max; i++)
  72.         {
  73.           QUIT;
  74.           printchar (VALUE_CONTENTS (val)[i], stream);
  75.         }
  76.       if (i < n)
  77.         fprintf_filtered (stream, "...");
  78.       fputc_filtered ('"', stream);
  79.     }
  80.       else
  81.     {
  82.       for (i = 0; i < n && i < print_max; i++)
  83.         {
  84.           if (i)
  85.         fprintf_filtered (stream, ", ");
  86.           val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
  87.              VALUE_ADDRESS (val) + typelen * i, stream, format);
  88.         }
  89.       if (i < n)
  90.         fprintf_filtered (stream, "...");
  91.     }
  92.       fputc_filtered ('}', stream);
  93.       return n * typelen;
  94.     }
  95.   else
  96.     {
  97.       /* A simple (nonrepeated) value */
  98.       /* If it is a pointer, indicate what it points to.  */
  99.       if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
  100.     {
  101.       fprintf_filtered (stream, "(");
  102.       type_print (VALUE_TYPE (val), "", stream, -1);
  103.       fprintf_filtered (stream, ") ");
  104.     }
  105.       return val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
  106.             VALUE_ADDRESS (val), stream, format);
  107.     }
  108. }
  109.  
  110. /* Print data of type TYPE located at VALADDR (within GDB),
  111.    which came from the inferior at address ADDRESS,
  112.    onto stdio stream STREAM according to FORMAT
  113.    (a letter or 0 for natural format).
  114.  
  115.    If the data are a string pointer, returns the number of
  116.    sting characters printed.  */
  117.  
  118. int
  119. val_print (type, valaddr, address, stream, format)
  120.      struct type *type;
  121.      char *valaddr;
  122.      CORE_ADDR address;
  123.      FILE *stream;
  124.      char format;
  125. {
  126.   register int i;
  127.   int len;
  128.   struct type *elttype;
  129.   int eltlen;
  130.   int val;
  131.   unsigned char c;
  132.  
  133.   QUIT;
  134.  
  135.   switch (TYPE_CODE (type))
  136.     {
  137.     case TYPE_CODE_ARRAY:
  138.       if (TYPE_LENGTH (type) >= 0)
  139.     {
  140.       elttype = TYPE_TARGET_TYPE (type);
  141.       eltlen = TYPE_LENGTH (elttype);
  142.       len = TYPE_LENGTH (type) / eltlen;
  143.       fprintf_filtered (stream, "{");
  144.       /* For an array of chars, print with string syntax.  */
  145.       if (eltlen == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
  146.           && format == 0)
  147.         {
  148.           fputc_filtered ('"', stream);
  149.           for (i = 0; i < len && i < print_max; i++)
  150.         {
  151.           QUIT;
  152.           printchar (valaddr[i], stream);
  153.         }
  154.           if (i < len)
  155.         fprintf_filtered (stream, "...");
  156.           fputc_filtered ('"', stream);
  157.         }
  158.       else
  159.         {
  160.           for (i = 0; i < len && i < print_max; i++)
  161.         {
  162.           if (i) fprintf_filtered (stream, ", ");
  163.           val_print (elttype, valaddr + i * eltlen,
  164.                  0, stream, format);
  165.         }
  166.           if (i < len)
  167.         fprintf_filtered (stream, "...");
  168.         }
  169.       fprintf_filtered (stream, "}");
  170.       break;
  171.     }
  172.       /* Array of unspecified length: treat like pointer.  */
  173.       valaddr = (char *) &address;
  174.  
  175.     case TYPE_CODE_PTR:
  176.       if (format)
  177.     {
  178.       print_scalar_formatted (valaddr, type, format, 0, stream);
  179.       break;
  180.     }
  181.       fprintf_filtered (stream, "0x%x", * (int *) valaddr);
  182.       /* For a pointer to char or unsigned char,
  183.      also print the string pointed to, unless pointer is null.  */
  184.  
  185.       /* For an array of chars, print with string syntax.  */
  186.       elttype = TYPE_TARGET_TYPE (type);
  187.       if (TYPE_LENGTH (elttype) == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
  188.       && format == 0
  189.       && unpack_long (type, valaddr) != 0)
  190.     {
  191.       fputc_filtered (' ', stream);
  192.       fputc_filtered ('"', stream);
  193.       for (i = 0; i < print_max; i++)
  194.         {
  195.           QUIT;
  196.           read_memory (unpack_long (type, valaddr) + i, &c, 1);
  197.           if (c == 0)
  198.         break;
  199.           printchar (c, stream);
  200.         }
  201.       fputc_filtered ('"', stream);
  202.       if (i == print_max)
  203.         fprintf_filtered (stream, "...");
  204.       fflush (stream);
  205.       /* Return number of characters printed, plus one for the
  206.          terminating null if we have "reached the end".  */
  207.       return i + (print_max && i != print_max);
  208.     }
  209.       break;
  210.  
  211.     case TYPE_CODE_STRUCT:
  212.     case TYPE_CODE_UNION:
  213.       fprintf_filtered (stream, "{");
  214.       len = TYPE_NFIELDS (type);
  215.       for (i = 0; i < len; i++)
  216.     {
  217.       if (i) fprintf_filtered (stream, ", ");
  218.       fprintf_filtered (stream, "%s = ", TYPE_FIELD_NAME (type, i));
  219.       if (TYPE_FIELD_PACKED (type, i))
  220.         {
  221.           val = unpack_field_as_long (type, valaddr, i);
  222.           val_print (TYPE_FIELD_TYPE (type, i), &val, 0, stream, format);
  223.         }
  224.       else
  225.         val_print (TYPE_FIELD_TYPE (type, i), 
  226.                valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
  227.                0, stream, format);
  228.     }
  229.       fprintf_filtered (stream, "}");
  230.       break;
  231.  
  232.     case TYPE_CODE_ENUM:
  233.       if (format)
  234.     {
  235.       print_scalar_formatted (valaddr, type, format, 0, stream);
  236.       break;
  237.     }
  238.       len = TYPE_NFIELDS (type);
  239.       val = unpack_long (builtin_type_int, valaddr);
  240.       for (i = 0; i < len; i++)
  241.     {
  242.       QUIT;
  243.       if (val == TYPE_FIELD_VALUE (type, i))
  244.         break;
  245.     }
  246.       if (i < len)
  247.     fprintf_filtered (stream, "%s", TYPE_FIELD_NAME (type, i));
  248.       else
  249.     fprintf_filtered (stream, "%d", val);
  250.       break;
  251.  
  252.     case TYPE_CODE_FUNC:
  253.       if (format)
  254.     {
  255.       print_scalar_formatted (valaddr, type, format, 0, stream);
  256.       break;
  257.     }
  258.       fprintf_filtered (stream, "{");
  259.       type_print (type, "", stream, -1);
  260.       fprintf_filtered (stream, "} ");
  261.       fprintf_filtered (stream, "0x%x", address);
  262.       break;
  263.  
  264.     case TYPE_CODE_INT:
  265.       if (format)
  266.     {
  267.       print_scalar_formatted (valaddr, type, format, 0, stream);
  268.       break;
  269.     }
  270.       fprintf_filtered (stream,
  271.            TYPE_UNSIGNED (type) ? "%u" : "%d",
  272.            unpack_long (type, valaddr));
  273.       if (TYPE_LENGTH (type) == 1)
  274.     {
  275.       fprintf_filtered (stream, " '");
  276.       printchar (unpack_long (type, valaddr), stream);
  277.       fputc_filtered ('\'', stream);
  278.     }
  279.       break;
  280.  
  281.     case TYPE_CODE_FLT:
  282.       if (format)
  283.     {
  284.       print_scalar_formatted (valaddr, type, format, 0, stream);
  285.       break;
  286.     }
  287. #ifdef IEEE_FLOAT
  288.       if (is_nan (unpack_double (type, valaddr)))
  289.     {
  290.       fprintf_filtered (stream, "Nan");
  291.       break;
  292.     }
  293. #endif
  294.       fprintf_filtered (stream, "%g", unpack_double (type, valaddr));
  295.       break;
  296.  
  297.     case TYPE_CODE_VOID:
  298.       fprintf_filtered (stream, "void");
  299.       break;
  300.  
  301.     default:
  302.